home *** CD-ROM | disk | FTP | other *** search
/ Champak 64 / Volume 64 - JOGO DISK .iso / Games / tutti-cuti.swf / scripts / DefineSprite_174 / frame_46 / DoAction.as
Text File  |  2008-04-22  |  138KB  |  2,279 lines

  1. var ┬º\x01┬º = 150;
  2. loop0:
  3. while(true)
  4. {
  5.    if(eval("\x01") == 150)
  6.    {
  7.       set("\x01",eval("\x01") - 4);
  8.       ┬º┬ºpush(true);
  9.       continue;
  10.    }
  11.    if(eval("\x01") == 506)
  12.    {
  13.       set("\x01",eval("\x01") - 196);
  14.       continue;
  15.    }
  16.    if(eval("\x01") == 724)
  17.    {
  18.       set("\x01",eval("\x01") + 210);
  19.       ┬º┬ºpush(true);
  20.       continue;
  21.    }
  22.    if(eval("\x01") == 103)
  23.    {
  24.       set("\x01",eval("\x01") + 207);
  25.       continue;
  26.    }
  27.    if(eval("\x01") == 858)
  28.    {
  29.       set("\x01",eval("\x01") - 372);
  30.       break;
  31.    }
  32.    if(eval("\x01") == 310)
  33.    {
  34.       set("\x01",eval("\x01") + 180);
  35.       ┬º┬ºpush(true);
  36.       continue;
  37.    }
  38.    if(eval("\x01") == 638)
  39.    {
  40.       set("\x01",eval("\x01") - 471);
  41.       continue;
  42.    }
  43.    if(eval("\x01") == 84)
  44.    {
  45.       set("\x01",eval("\x01") + 680);
  46.       continue;
  47.    }
  48.    if(eval("\x01") == 241)
  49.    {
  50.       set("\x01",eval("\x01") + 397);
  51.       break;
  52.    }
  53.    if(eval("\x01") == 493)
  54.    {
  55.       set("\x01",eval("\x01") + 155);
  56.       continue;
  57.    }
  58.    if(eval("\x01") == 934)
  59.    {
  60.       set("\x01",eval("\x01") - 76);
  61.       if(┬º┬ºpop())
  62.       {
  63.          set("\x01",eval("\x01") - 372);
  64.       }
  65.       continue;
  66.    }
  67.    if(eval("\x01") == 233)
  68.    {
  69.       set("\x01",eval("\x01") + 80);
  70.       ┬º┬ºpush(true);
  71.       continue;
  72.    }
  73.    if(eval("\x01") == 349)
  74.    {
  75.       set("\x01",eval("\x01") + 175);
  76.       ┬º┬ºgoto(addr1298);
  77.    }
  78.    if(eval("\x01") == 292)
  79.    {
  80.       set("\x01",eval("\x01") + 432);
  81.       continue;
  82.    }
  83.    if(eval("\x01") == 879)
  84.    {
  85.       set("\x01",eval("\x01") - 231);
  86.       continue;
  87.    }
  88.    if(eval("\x01") == 762)
  89.    {
  90.       set("\x01",eval("\x01") - 38);
  91.       continue;
  92.    }
  93.    if(eval("\x01") == 490)
  94.    {
  95.       set("\x01",eval("\x01") + 204);
  96.       if(┬º┬ºpop())
  97.       {
  98.          set("\x01",eval("\x01") - 402);
  99.       }
  100.       continue;
  101.    }
  102.    if(eval("\x01") == 860)
  103.    {
  104.       set("\x01",eval("\x01") - 511);
  105.       if(┬º┬ºpop())
  106.       {
  107.          set("\x01",eval("\x01") + 175);
  108.       }
  109.       continue;
  110.    }
  111.    if(eval("\x01") == 927)
  112.    {
  113.       set("\x01",eval("\x01") - 694);
  114.       continue;
  115.    }
  116.    if(eval("\x01") == 486)
  117.    {
  118.       set("\x01",eval("\x01") + 278);
  119.       continue;
  120.    }
  121.    if(eval("\x01") == 540)
  122.    {
  123.       set("\x01",eval("\x01") - 34);
  124.       break;
  125.    }
  126.    if(eval("\x01") == 648)
  127.    {
  128.       set("\x01",eval("\x01") - 543);
  129.       ┬º┬ºpush(true);
  130.       continue;
  131.    }
  132.    if(eval("\x01") == 694)
  133.    {
  134.       set("\x01",eval("\x01") - 402);
  135.       loop17:
  136.       while(true)
  137.       {
  138.          set("\x01",eval("\x01") + 245);
  139.          if(┬º┬ºpop())
  140.          {
  141.             set("\x01",eval("\x01") + 91);
  142.          }
  143.          while(true)
  144.          {
  145.             if(eval("\x01") == 897)
  146.             {
  147.                set("\x01",eval("\x01") - 320);
  148.                ┬º┬ºpush(true);
  149.                continue;
  150.             }
  151.             if(eval("\x01") == 881)
  152.             {
  153.                set("\x01",eval("\x01") - 555);
  154.                ┬º┬ºpush(true);
  155.                continue;
  156.             }
  157.             if(eval("\x01") == 835)
  158.             {
  159.                set("\x01",eval("\x01") - 369);
  160.                ┬º┬ºpush(┬º┬ºpop() % ┬º┬ºpop());
  161.                break loop0;
  162.             }
  163.             if(eval("\x01") == 380)
  164.             {
  165.                set("\x01",eval("\x01") + 35);
  166.                continue;
  167.             }
  168.             if(eval("\x01") == 0)
  169.             {
  170.                set("\x01",eval("\x01") + 843);
  171.                if(┬º┬ºpop())
  172.                {
  173.                   set("\x01",eval("\x01") - 415);
  174.                }
  175.                continue;
  176.             }
  177.             if(eval("\x01") == 874)
  178.             {
  179.                set("\x01",eval("\x01") - 564);
  180.                ┬º┬ºpush(true);
  181.                continue;
  182.             }
  183.             if(eval("\x01") == 601)
  184.             {
  185.                set("\x01",eval("\x01") - 601);
  186.                ┬º┬ºpush(true);
  187.                continue;
  188.             }
  189.             if(eval("\x01") == 353)
  190.             {
  191.                set("\x01",eval("\x01") + 521);
  192.                continue;
  193.             }
  194.             if(eval("\x01") == 129)
  195.             {
  196.                set("\x01",eval("\x01") + 286);
  197.                continue;
  198.             }
  199.             if(eval("\x01") == 582)
  200.             {
  201.                set("\x01",eval("\x01") - 472);
  202.                ┬º┬ºpush(true);
  203.                continue;
  204.             }
  205.             if(eval("\x01") == 577)
  206.             {
  207.                set("\x01",eval("\x01") + 257);
  208.                if(┬º┬ºpop())
  209.                {
  210.                   set("\x01",eval("\x01") - 705);
  211.                }
  212.                continue;
  213.             }
  214.             if(eval("\x01") == 614)
  215.             {
  216.                set("\x01",eval("\x01") - 578);
  217.                continue;
  218.             }
  219.             if(eval("\x01") == 572)
  220.             {
  221.                set("\x01",eval("\x01") - 345);
  222.                continue;
  223.             }
  224.             if(eval("\x01") == 865)
  225.             {
  226.                set("\x01",eval("\x01") - 251);
  227.                break loop0;
  228.             }
  229.             if(eval("\x01") == 489)
  230.             {
  231.                set("\x01",eval("\x01") - 453);
  232.                continue;
  233.             }
  234.             if(eval("\x01") == 310)
  235.             {
  236.                set("\x01",eval("\x01") + 525);
  237.                if(┬º┬ºpop())
  238.                {
  239.                   set("\x01",eval("\x01") - 369);
  240.                }
  241.                continue;
  242.             }
  243.             if(eval("\x01") == 110)
  244.             {
  245.                set("\x01",eval("\x01") + 755);
  246.                if(┬º┬ºpop())
  247.                {
  248.                   set("\x01",eval("\x01") - 251);
  249.                }
  250.                continue;
  251.             }
  252.             if(eval("\x01") == 20)
  253.             {
  254.                set("\x01",eval("\x01") + 581);
  255.                continue;
  256.             }
  257.             if(eval("\x01") == 415)
  258.             {
  259.                set("\x01",eval("\x01") - 99);
  260.                ┬º┬ºpush(true);
  261.                continue;
  262.             }
  263.             if(eval("\x01") == 523)
  264.             {
  265.                set("\x01",eval("\x01") - 457);
  266.                ┬º┬ºgoto(addr2081);
  267.             }
  268.             else
  269.             {
  270.                if(eval("\x01") == 326)
  271.                {
  272.                   break;
  273.                }
  274.                if(eval("\x01") == 571)
  275.                {
  276.                   set("\x01",eval("\x01") + 91);
  277.                   break loop0;
  278.                }
  279.                if(eval("\x01") == 986)
  280.                {
  281.                   set("\x01",eval("\x01") - 112);
  282.                   continue;
  283.                }
  284.                if(eval("\x01") == 843)
  285.                {
  286.                   break loop17;
  287.                }
  288.                if(eval("\x01") == 428)
  289.                {
  290.                   set("\x01",eval("\x01") + 138);
  291.                   continue;
  292.                }
  293.                if(eval("\x01") == 89)
  294.                {
  295.                   set("\x01",eval("\x01") + 722);
  296.                   break loop0;
  297.                }
  298.                if(eval("\x01") == 597)
  299.                {
  300.                   set("\x01",eval("\x01") - 74);
  301.                   if(┬º┬ºpop())
  302.                   {
  303.                      set("\x01",eval("\x01") - 457);
  304.                   }
  305.                   continue;
  306.                }
  307.                if(eval("\x01") == 662)
  308.                {
  309.                   set("\x01",eval("\x01") - 435);
  310.                   continue;
  311.                }
  312.                if(eval("\x01") == 74)
  313.                {
  314.                   set("\x01",eval("\x01") + 492);
  315.                   continue;
  316.                }
  317.                if(eval("\x01") == 66)
  318.                {
  319.                   set("\x01",eval("\x01") + 535);
  320.                   continue;
  321.                }
  322.                if(eval("\x01") == 316)
  323.                {
  324.                   set("\x01",eval("\x01") + 472);
  325.                   if(┬º┬ºpop())
  326.                   {
  327.                      set("\x01",eval("\x01") + 113);
  328.                   }
  329.                   continue;
  330.                }
  331.                if(eval("\x01") == 589)
  332.                {
  333.                   set("\x01",eval("\x01") + 292);
  334.                   continue;
  335.                }
  336.                if(eval("\x01") != 834)
  337.                {
  338.                   if(eval("\x01") == 788)
  339.                   {
  340.                      set("\x01",eval("\x01") + 113);
  341.                      break loop0;
  342.                   }
  343.                   if(eval("\x01") == 901)
  344.                   {
  345.                      set("\x01",eval("\x01") - 577);
  346.                   }
  347.                   else if(eval("\x01") == 811)
  348.                   {
  349.                      set("\x01",eval("\x01") + 70);
  350.                   }
  351.                   else if(eval("\x01") == 910)
  352.                   {
  353.                      set("\x01",eval("\x01") - 821);
  354.                      if(┬º┬ºpop())
  355.                      {
  356.                         set("\x01",eval("\x01") + 722);
  357.                      }
  358.                   }
  359.                   else if(eval("\x01") == 36)
  360.                   {
  361.                      set("\x01",eval("\x01") + 561);
  362.                      ┬º┬ºpush(true);
  363.                   }
  364.                   else if(eval("\x01") == 466)
  365.                   {
  366.                      set("\x01",eval("\x01") + 116);
  367.                   }
  368.                   else if(eval("\x01") == 227)
  369.                   {
  370.                      set("\x01",eval("\x01") + 303);
  371.                      ┬º┬ºpush(true);
  372.                   }
  373.                   else
  374.                   {
  375.                      if(eval("\x01") == 715)
  376.                      {
  377.                         set("\x01",eval("\x01") + 271);
  378.                         break loop0;
  379.                      }
  380.                      if(eval("\x01") == 247)
  381.                      {
  382.                         set("\x01",eval("\x01") + 335);
  383.                      }
  384.                      else if(eval("\x01") == 530)
  385.                      {
  386.                         set("\x01",eval("\x01") + 185);
  387.                         if(┬º┬ºpop())
  388.                         {
  389.                            set("\x01",eval("\x01") + 271);
  390.                         }
  391.                      }
  392.                      else
  393.                      {
  394.                         if(eval("\x01") == 566)
  395.                         {
  396.                            set("\x01",eval("\x01") + 288);
  397.                            _parent.red.gotoAndStop(2);
  398.                            play();
  399.                            break loop0;
  400.                         }
  401.                         if(eval("\x01") == 71)
  402.                         {
  403.                            set("\x01",eval("\x01") + 253);
  404.                         }
  405.                         else
  406.                         {
  407.                            if(eval("\x01") != 324)
  408.                            {
  409.                               if(eval("\x01") == 854)
  410.                               {
  411.                                  set("\x01",eval("\x01") - 854);
  412.                                  break loop0;
  413.                               }
  414.                               break loop0;
  415.                            }
  416.                            set("\x01",eval("\x01") + 586);
  417.                            ┬º┬ºpush(true);
  418.                         }
  419.                      }
  420.                   }
  421.                   continue;
  422.                }
  423.                set("\x01",eval("\x01") - 705);
  424.                gotoAndStop("\x19∩┐╜∩┐╜∩┐╜\x03∩┐╜ßå┐t∩┐╜?∩┐╜\x11$D0\x11∩┐╜∩┐╜)%\x12∩┐╜f∩┐╜JY\x01\x1a@,L\x19\x0e");
  425.                ┬º┬ºpush(┬º┬ºpop().substr(┬º┬ºpop(),┬º┬ºpop()));
  426.             }
  427.             ┬º┬ºgoto(addr210);
  428.          }
  429.       }
  430.       set("\x01",eval("\x01") - 415);
  431.       break;
  432.    }
  433.    if(eval("\x01") == 165)
  434.    {
  435.       set("\x01",eval("\x01") + 340);
  436.       ┬º┬ºpush(true);
  437.       continue;
  438.    }
  439.    if(eval("\x01") == 764)
  440.    {
  441.       set("\x01",eval("\x01") + 96);
  442.       ┬º┬ºpush(true);
  443.       continue;
  444.    }
  445.    if(eval("\x01") == 524)
  446.    {
  447.       set("\x01",eval("\x01") + 96);
  448.       continue;
  449.    }
  450.    if(eval("\x01") == 505)
  451.    {
  452.       set("\x01",eval("\x01") + 35);
  453.       if(┬º┬ºpop())
  454.       {
  455.          set("\x01",eval("\x01") - 34);
  456.       }
  457.       continue;
  458.    }
  459.    if(eval("\x01") == 424)
  460.    {
  461.       set("\x01",eval("\x01") + 455);
  462.       break;
  463.    }
  464.    if(eval("\x01") == 822)
  465.    {
  466.       set("\x01",eval("\x01") - 202);
  467.       continue;
  468.    }
  469.    if(eval("\x01") == 620)
  470.    {
  471.       set("\x01",eval("\x01") - 309);
  472.       continue;
  473.    }
  474.    if(eval("\x01") == 751)
  475.    {
  476.       set("\x01",eval("\x01") - 586);
  477.       continue;
  478.    }
  479.    if(eval("\x01") == 311)
  480.    {
  481.       set("\x01",eval("\x01") + 1);
  482.       if(!eval("∩┐╜F")["∩┐╜:U`∩┐╜∩┐╜"])
  483.       {
  484.          eval("∩┐╜F")["∩┐╜∩┐╜^c∩┐╜"]("∩┐╜∩┐╜∩┐╜");
  485.       }
  486.       else
  487.       {
  488.          eval("∩┐╜F")["∩┐╜∩┐╜^c∩┐╜"]("z∩┐╜∩┐╜∩┐╜");
  489.       }
  490.       stop();
  491.       break;
  492.    }
  493.    if(eval("\x01") == 312)
  494.    {
  495.       set("\x01",eval("\x01") - 312);
  496.       break;
  497.    }
  498.    if(eval("\x01") == 42)
  499.    {
  500.       set("\x01",eval("\x01") + 123);
  501.       continue;
  502.    }
  503.    if(eval("\x01") == 929)
  504.    {
  505.       set("\x01",eval("\x01") - 887);
  506.       break;
  507.    }
  508.    if(eval("\x01") != 695)
  509.    {
  510.       if(eval("\x01") == 146)
  511.       {
  512.          set("\x01",eval("\x01") + 278);
  513.          if(┬º┬ºpop())
  514.          {
  515.             set("\x01",eval("\x01") + 455);
  516.          }
  517.       }
  518.       else if(eval("\x01") == 105)
  519.       {
  520.          set("\x01",eval("\x01") + 136);
  521.          if(┬º┬ºpop())
  522.          {
  523.             set("\x01",eval("\x01") + 397);
  524.          }
  525.       }
  526.       else if(eval("\x01") == 763)
  527.       {
  528.          set("\x01",eval("\x01") - 596);
  529.       }
  530.       else if(eval("\x01") == 167)
  531.       {
  532.          set("\x01",eval("\x01") + 560);
  533.          ┬º┬ºpush(true);
  534.       }
  535.       else if(eval("\x01") == 727)
  536.       {
  537.          set("\x01",eval("\x01") - 32);
  538.          if(┬º┬ºpop())
  539.          {
  540.             set("\x01",eval("\x01") + 232);
  541.          }
  542.       }
  543.       else if(eval("\x01") == 313)
  544.       {
  545.          set("\x01",eval("\x01") + 616);
  546.          if(┬º┬ºpop())
  547.          {
  548.             set("\x01",eval("\x01") - 887);
  549.          }
  550.       }
  551.       else
  552.       {
  553.          if(eval("\x01") != 12)
  554.          {
  555.             break;
  556.          }
  557.          set("\x01",eval("\x01") + 221);
  558.       }
  559.       continue;
  560.    }
  561.    set("\x01",eval("\x01") + 232);
  562.    loop1:
  563.    while(true)
  564.    {
  565.       set(┬º┬ºpop(),eval("\x01") - 237);
  566.       loop2:
  567.       while(true)
  568.       {
  569.          while(true)
  570.          {
  571.             if(eval("\x01") == 715)
  572.             {
  573.                set("\x01",eval("\x01") + 107);
  574.                ┬º┬ºpush(true);
  575.                continue;
  576.             }
  577.             if(eval("\x01") == 822)
  578.             {
  579.                break;
  580.             }
  581.             if(eval("\x01") == 704)
  582.             {
  583.                addr1298:
  584.                set(┬º┬ºpop(),eval(┬º┬ºpop()) - 237);
  585.                loop14:
  586.                while(true)
  587.                {
  588.                   while(true)
  589.                   {
  590.                      if(eval("\x01") == 514)
  591.                      {
  592.                         set("\x01",eval("\x01") - 372);
  593.                         ┬º┬ºpush(true);
  594.                         continue;
  595.                      }
  596.                      if(eval("\x01") == 300)
  597.                      {
  598.                         set("\x01",eval("\x01") - 10);
  599.                         continue;
  600.                      }
  601.                      if(eval("\x01") == 670)
  602.                      {
  603.                         break loop14;
  604.                      }
  605.                      if(eval("\x01") == 845)
  606.                      {
  607.                         set("\x01",eval("\x01") - 554);
  608.                         continue;
  609.                      }
  610.                      if(eval("\x01") == 857)
  611.                      {
  612.                         set("\x01",eval("\x01") - 392);
  613.                         if(!eval("∩┐╜\x1e\x18g\x04∩┐╜V\x14")["z∩┐╜\x1bT}{/"])
  614.                         {
  615.                            eval("∩┐╜\x1e\x18g\x04∩┐╜V\x14")[┬º┬ºconstant(3)](┬º┬ºconstant(2));
  616.                         }
  617.                         else
  618.                         {
  619.                            eval("∩┐╜\x1e\x18g\x04∩┐╜V\x14")[┬º┬ºconstant(3)](┬º┬ºconstant(4));
  620.                         }
  621.                         stop();
  622.                         break loop0;
  623.                      }
  624.                      if(eval("\x01") == 280)
  625.                      {
  626.                         set("\x01",eval("\x01") + 408);
  627.                         if(┬º┬ºpop())
  628.                         {
  629.                            set("\x01",eval("\x01") - 159);
  630.                         }
  631.                         continue;
  632.                      }
  633.                      if(eval("\x01") == 345)
  634.                      {
  635.                         break;
  636.                      }
  637.                      if(eval("\x01") == 291)
  638.                      {
  639.                         set("\x01",eval("\x01") - 11);
  640.                         ┬º┬ºpush(true);
  641.                         continue;
  642.                      }
  643.                      if(eval("\x01") == 246)
  644.                      {
  645.                         set("\x01",eval("\x01") + 424);
  646.                         if(┬º┬ºpop())
  647.                         {
  648.                            set("\x01",eval("\x01") - 325);
  649.                         }
  650.                         continue;
  651.                      }
  652.                      if(eval("\x01") == 571)
  653.                      {
  654.                         set("\x01",eval("\x01") - 52);
  655.                         break loop0;
  656.                      }
  657.                      if(eval("\x01") == 290)
  658.                      {
  659.                         set("\x01",eval("\x01") - 130);
  660.                         ┬º┬ºpush(true);
  661.                         continue;
  662.                      }
  663.                      if(eval("\x01") == 519)
  664.                      {
  665.                         set("\x01",eval("\x01") - 228);
  666.                         continue;
  667.                      }
  668.                      if(eval("\x01") == 574)
  669.                      {
  670.                         set("\x01",eval("\x01") - 181);
  671.                         break loop0;
  672.                      }
  673.                      if(eval("\x01") == 142)
  674.                      {
  675.                         set("\x01",eval("\x01") + 432);
  676.                         if(┬º┬ºpop())
  677.                         {
  678.                            set("\x01",eval("\x01") - 181);
  679.                         }
  680.                         continue;
  681.                      }
  682.                      if(eval("\x01") == 930)
  683.                      {
  684.                         set("\x01",eval("\x01") - 684);
  685.                         ┬º┬ºpush(true);
  686.                         continue;
  687.                      }
  688.                      if(eval("\x01") == 997)
  689.                      {
  690.                         set("\x01",eval("\x01") - 67);
  691.                         continue;
  692.                      }
  693.                      if(eval("\x01") == 160)
  694.                      {
  695.                         set("\x01",eval("\x01") + 411);
  696.                         if(┬º┬ºpop())
  697.                         {
  698.                            set("\x01",eval("\x01") - 52);
  699.                         }
  700.                         continue;
  701.                      }
  702.                      if(eval("\x01") != 688)
  703.                      {
  704.                         if(eval("\x01") == 529)
  705.                         {
  706.                            set("\x01",eval("\x01") + 428);
  707.                         }
  708.                         else if(eval("\x01") == 483)
  709.                         {
  710.                            set("\x01",eval("\x01") + 474);
  711.                         }
  712.                         else if(eval("\x01") == 957)
  713.                         {
  714.                            set("\x01",eval("\x01") - 100);
  715.                         }
  716.                         else
  717.                         {
  718.                            if(eval("\x01") == 465)
  719.                            {
  720.                               set("\x01",eval("\x01") - 465);
  721.                               break loop0;
  722.                            }
  723.                            if(eval("\x01") != 393)
  724.                            {
  725.                               break loop0;
  726.                            }
  727.                            set("\x01",eval("\x01") + 537);
  728.                         }
  729.                         continue;
  730.                      }
  731.                      set("\x01",eval("\x01") - 159);
  732.                      loop16:
  733.                      while(true)
  734.                      {
  735.                         set(┬º┬ºpop(),┬º┬ºpop());
  736.                         ┬º┬ºpush(true);
  737.                         addr2500:
  738.                         while(true)
  739.                         {
  740.                            if(eval("\x01") != 586)
  741.                            {
  742.                               if(eval("\x01") != 167)
  743.                               {
  744.                                  if(eval("\x01") != 0)
  745.                                  {
  746.                                     if(eval("\x01") != 368)
  747.                                     {
  748.                                        if(eval("\x01") == 785)
  749.                                        {
  750.                                           set("\x01",eval("\x01") - 540);
  751.                                           break loop0;
  752.                                        }
  753.                                        if(eval("\x01") != 318)
  754.                                        {
  755.                                           if(eval("\x01") != 139)
  756.                                           {
  757.                                              if(eval("\x01") == 208)
  758.                                              {
  759.                                                 set("\x01",eval("\x01") + 160);
  760.                                              }
  761.                                              else
  762.                                              {
  763.                                                 if(eval("\x01") == 316)
  764.                                                 {
  765.                                                    set("\x01",eval("\x01") - 108);
  766.                                                    if(┬º┬ºpop())
  767.                                                    {
  768.                                                       set("\x01",eval("\x01") + 160);
  769.                                                    }
  770.                                                    continue;
  771.                                                 }
  772.                                                 if(eval("\x01") != 202)
  773.                                                 {
  774.                                                    if(eval("\x01") == 340)
  775.                                                    {
  776.                                                       set("\x01",eval("\x01") + 29);
  777.                                                    }
  778.                                                    else if(eval("\x01") == 243)
  779.                                                    {
  780.                                                       set("\x01",eval("\x01") + 502);
  781.                                                    }
  782.                                                    else
  783.                                                    {
  784.                                                       if(eval("\x01") == 665)
  785.                                                       {
  786.                                                          set("\x01",eval("\x01") - 414);
  787.                                                          break loop0;
  788.                                                       }
  789.                                                       if(eval("\x01") == 25)
  790.                                                       {
  791.                                                          set("\x01",eval("\x01") + 177);
  792.                                                          if(┬º┬ºpop())
  793.                                                          {
  794.                                                             set("\x01",eval("\x01") + 41);
  795.                                                          }
  796.                                                       }
  797.                                                       else if(eval("\x01") == 105)
  798.                                                       {
  799.                                                          set("\x01",eval("\x01") + 569);
  800.                                                       }
  801.                                                       else if(eval("\x01") == 458)
  802.                                                       {
  803.                                                          set("\x01",eval("\x01") - 346);
  804.                                                       }
  805.                                                       else if(eval("\x01") == 155)
  806.                                                       {
  807.                                                          set("\x01",eval("\x01") + 203);
  808.                                                          if(┬º┬ºpop())
  809.                                                          {
  810.                                                             set("\x01",eval("\x01") - 191);
  811.                                                          }
  812.                                                       }
  813.                                                       else
  814.                                                       {
  815.                                                          if(eval("\x01") == 745)
  816.                                                          {
  817.                                                             set("\x01",eval("\x01") - 360);
  818.                                                             _parent.red.gotoAndStop(1);
  819.                                                             break loop0;
  820.                                                          }
  821.                                                          if(eval("\x01") == 369)
  822.                                                          {
  823.                                                             set("\x01",eval("\x01") + 182);
  824.                                                             ┬º┬ºpush(true);
  825.                                                          }
  826.                                                          else if(eval("\x01") == 482)
  827.                                                          {
  828.                                                             set("\x01",eval("\x01") - 302);
  829.                                                             if(┬º┬ºpop())
  830.                                                             {
  831.                                                                set("\x01",eval("\x01") + 280);
  832.                                                             }
  833.                                                          }
  834.                                                          else if(eval("\x01") == 829)
  835.                                                          {
  836.                                                             set("\x01",eval("\x01") - 587);
  837.                                                             if(┬º┬ºpop())
  838.                                                             {
  839.                                                                set("\x01",eval("\x01") + 426);
  840.                                                             }
  841.                                                          }
  842.                                                          else
  843.                                                          {
  844.                                                             if(eval("\x01") == 385)
  845.                                                             {
  846.                                                                set("\x01",eval("\x01") - 385);
  847.                                                                break loop0;
  848.                                                             }
  849.                                                             if(eval("\x01") == 879)
  850.                                                             {
  851.                                                                set("\x01",eval("\x01") - 94);
  852.                                                                if(┬º┬ºpop())
  853.                                                                {
  854.                                                                   set("\x01",eval("\x01") - 540);
  855.                                                                }
  856.                                                             }
  857.                                                             else if(eval("\x01") == 674)
  858.                                                             {
  859.                                                                set("\x01",eval("\x01") + 155);
  860.                                                                ┬º┬ºpush(true);
  861.                                                             }
  862.                                                             else
  863.                                                             {
  864.                                                                if(eval("\x01") == 242)
  865.                                                                {
  866.                                                                   set("\x01",eval("\x01") + 426);
  867.                                                                   ┬º┬ºpop() extends ┬º┬ºpop();
  868.                                                                   break loop0;
  869.                                                                }
  870.                                                                if(eval("\x01") == 551)
  871.                                                                {
  872.                                                                   set("\x01",eval("\x01") - 23);
  873.                                                                   if(┬º┬ºpop())
  874.                                                                   {
  875.                                                                      set("\x01",eval("\x01") - 36);
  876.                                                                   }
  877.                                                                }
  878.                                                                else if(eval("\x01") == 550)
  879.                                                                {
  880.                                                                   set("\x01",eval("\x01") - 68);
  881.                                                                   ┬º┬ºpush(true);
  882.                                                                }
  883.                                                                else if(eval("\x01") == 530)
  884.                                                                {
  885.                                                                   set("\x01",eval("\x01") + 254);
  886.                                                                }
  887.                                                                else if(eval("\x01") == 668)
  888.                                                                {
  889.                                                                   set("\x01",eval("\x01") - 118);
  890.                                                                }
  891.                                                                else if(eval("\x01") == 335)
  892.                                                                {
  893.                                                                   set("\x01",eval("\x01") - 310);
  894.                                                                   ┬º┬ºpush(true);
  895.                                                                }
  896.                                                                else if(eval("\x01") == 568)
  897.                                                                {
  898.                                                                   set("\x01",eval("\x01") - 233);
  899.                                                                }
  900.                                                                else if(eval("\x01") == 666)
  901.                                                                {
  902.                                                                   set("\x01",eval("\x01") - 116);
  903.                                                                }
  904.                                                                else if(eval("\x01") == 492)
  905.                                                                {
  906.                                                                   set("\x01",eval("\x01") - 380);
  907.                                                                }
  908.                                                                else if(eval("\x01") == 112)
  909.                                                                {
  910.                                                                   set("\x01",eval("\x01") + 204);
  911.                                                                   ┬º┬ºpush(true);
  912.                                                                }
  913.                                                                else if(eval("\x01") == 54)
  914.                                                                {
  915.                                                                   set("\x01",eval("\x01") + 611);
  916.                                                                   if(┬º┬ºpop())
  917.                                                                   {
  918.                                                                      set("\x01",eval("\x01") - 414);
  919.                                                                   }
  920.                                                                }
  921.                                                                else
  922.                                                                {
  923.                                                                   if(eval("\x01") == 528)
  924.                                                                   {
  925.                                                                      set("\x01",eval("\x01") - 36);
  926.                                                                      break loop0;
  927.                                                                   }
  928.                                                                   if(eval("\x01") == 911)
  929.                                                                   {
  930.                                                                      ┬º┬ºpush("\x01");
  931.                                                                      ┬º┬ºpush(eval("\x01") - 857);
  932.                                                                      continue loop16;
  933.                                                                   }
  934.                                                                   if(eval("\x01") == 784)
  935.                                                                   {
  936.                                                                      set("\x01",eval("\x01") + 95);
  937.                                                                      ┬º┬ºpush(true);
  938.                                                                   }
  939.                                                                   else if(eval("\x01") == 80)
  940.                                                                   {
  941.                                                                      set("\x01",eval("\x01") + 831);
  942.                                                                   }
  943.                                                                   else if(eval("\x01") == 251)
  944.                                                                   {
  945.                                                                      set("\x01",eval("\x01") + 118);
  946.                                                                   }
  947.                                                                   else
  948.                                                                   {
  949.                                                                      if(eval("\x01") == 358)
  950.                                                                      {
  951.                                                                         set("\x01",eval("\x01") - 191);
  952.                                                                         break loop0;
  953.                                                                      }
  954.                                                                      if(eval("\x01") == 460)
  955.                                                                      {
  956.                                                                         set("\x01",eval("\x01") + 451);
  957.                                                                      }
  958.                                                                      else
  959.                                                                      {
  960.                                                                         if(eval("\x01") == 821)
  961.                                                                         {
  962.                                                                            set("\x01",eval("\x01") - 716);
  963.                                                                            play();
  964.                                                                            ┬º┬ºpush(┬º┬ºpop() instanceof ┬º┬ºpop() - 1);
  965.                                                                            loop7:
  966.                                                                            while(true)
  967.                                                                            {
  968.                                                                               while(true)
  969.                                                                               {
  970.                                                                                  if(eval("\x01") == 24)
  971.                                                                                  {
  972.                                                                                     set("\x01",eval("\x01") + 601);
  973.                                                                                     ┬º┬ºpush(true);
  974.                                                                                     continue;
  975.                                                                                  }
  976.                                                                                  if(eval("\x01") == 518)
  977.                                                                                  {
  978.                                                                                     set("\x01",eval("\x01") + 172);
  979.                                                                                     continue;
  980.                                                                                  }
  981.                                                                                  if(eval("\x01") == 983)
  982.                                                                                  {
  983.                                                                                     set("\x01",eval("\x01") - 656);
  984.                                                                                     continue;
  985.                                                                                  }
  986.                                                                                  if(eval("\x01") == 405)
  987.                                                                                  {
  988.                                                                                     set("\x01",eval("\x01") - 78);
  989.                                                                                     continue;
  990.                                                                                  }
  991.                                                                                  if(eval("\x01") == 456)
  992.                                                                                  {
  993.                                                                                     set("\x01",eval("\x01") + 234);
  994.                                                                                     continue;
  995.                                                                                  }
  996.                                                                                  if(eval("\x01") == 639)
  997.                                                                                  {
  998.                                                                                     set("\x01",eval("\x01") + 274);
  999.                                                                                     ┬º┬ºpush(true);
  1000.                                                                                     continue;
  1001.                                                                                  }
  1002.                                                                                  if(eval("\x01") == 423)
  1003.                                                                                  {
  1004.                                                                                     set("\x01",eval("\x01") + 216);
  1005.                                                                                     continue;
  1006.                                                                                  }
  1007.                                                                                  if(eval("\x01") != 318)
  1008.                                                                                  {
  1009.                                                                                     if(eval("\x01") == 85)
  1010.                                                                                     {
  1011.                                                                                        set("\x01",eval("\x01") + 638);
  1012.                                                                                        ┬º┬ºpush(true);
  1013.                                                                                     }
  1014.                                                                                     else if(eval("\x01") == 366)
  1015.                                                                                     {
  1016.                                                                                        set("\x01",eval("\x01") - 281);
  1017.                                                                                     }
  1018.                                                                                     else if(eval("\x01") == 327)
  1019.                                                                                     {
  1020.                                                                                        set("\x01",eval("\x01") - 81);
  1021.                                                                                        ┬º┬ºpush(true);
  1022.                                                                                     }
  1023.                                                                                     else if(eval("\x01") == 913)
  1024.                                                                                     {
  1025.                                                                                        set("\x01",eval("\x01") - 72);
  1026.                                                                                        if(┬º┬ºpop())
  1027.                                                                                        {
  1028.                                                                                           set("\x01",eval("\x01") - 385);
  1029.                                                                                        }
  1030.                                                                                     }
  1031.                                                                                     else if(eval("\x01") == 723)
  1032.                                                                                     {
  1033.                                                                                        set("\x01",eval("\x01") + 209);
  1034.                                                                                        if(┬º┬ºpop())
  1035.                                                                                        {
  1036.                                                                                           set("\x01",eval("\x01") - 554);
  1037.                                                                                        }
  1038.                                                                                     }
  1039.                                                                                     else
  1040.                                                                                     {
  1041.                                                                                        if(eval("\x01") == 28)
  1042.                                                                                        {
  1043.                                                                                           break;
  1044.                                                                                        }
  1045.                                                                                        if(eval("\x01") == 591)
  1046.                                                                                        {
  1047.                                                                                           set("\x01",eval("\x01") - 273);
  1048.                                                                                           if(┬º┬ºpop())
  1049.                                                                                           {
  1050.                                                                                              set("\x01",eval("\x01") + 87);
  1051.                                                                                           }
  1052.                                                                                        }
  1053.                                                                                        else
  1054.                                                                                        {
  1055.                                                                                           if(eval("\x01") == 109)
  1056.                                                                                           {
  1057.                                                                                              set("\x01",eval("\x01") + 257);
  1058.                                                                                              ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  1059.                                                                                              break loop0;
  1060.                                                                                           }
  1061.                                                                                           if(eval("\x01") == 855)
  1062.                                                                                           {
  1063.                                                                                              set("\x01",eval("\x01") - 19);
  1064.                                                                                              if(!eval("∩┐╜∩┐╜∩┐╜∩┐╜Q∩┐╜∩┐╜")["o∩┐╜1i"])
  1065.                                                                                              {
  1066.                                                                                                 eval("∩┐╜∩┐╜∩┐╜∩┐╜Q∩┐╜∩┐╜")["q∩┐╜\x06∩┐╜∩┐╜"]("∩┐╜\x0b∩┐╜∩┐╜k 3∩┐╜");
  1067.                                                                                              }
  1068.                                                                                              else
  1069.                                                                                              {
  1070.                                                                                                 eval("∩┐╜∩┐╜∩┐╜∩┐╜Q∩┐╜∩┐╜")["q∩┐╜\x06∩┐╜∩┐╜"]("WsO∩┐╜\x0e\x1c");
  1071.                                                                                              }
  1072.                                                                                              stop();
  1073.                                                                                              break loop0;
  1074.                                                                                           }
  1075.                                                                                           if(eval("\x01") == 383)
  1076.                                                                                           {
  1077.                                                                                              set("\x01",eval("\x01") - 298);
  1078.                                                                                           }
  1079.                                                                                           else if(eval("\x01") == 349)
  1080.                                                                                           {
  1081.                                                                                              set("\x01",eval("\x01") + 139);
  1082.                                                                                           }
  1083.                                                                                           else
  1084.                                                                                           {
  1085.                                                                                              if(eval("\x01") == 394)
  1086.                                                                                              {
  1087.                                                                                                 set("\x01",eval("\x01") - 305);
  1088.                                                                                                 break loop0;
  1089.                                                                                              }
  1090.                                                                                              if(eval("\x01") == 34)
  1091.                                                                                              {
  1092.                                                                                                 set("\x01",eval("\x01") + 360);
  1093.                                                                                                 if(┬º┬ºpop())
  1094.                                                                                                 {
  1095.                                                                                                    set("\x01",eval("\x01") - 305);
  1096.                                                                                                 }
  1097.                                                                                              }
  1098.                                                                                              else if(eval("\x01") == 690)
  1099.                                                                                              {
  1100.                                                                                                 set("\x01",eval("\x01") - 99);
  1101.                                                                                                 ┬º┬ºpush(true);
  1102.                                                                                              }
  1103.                                                                                              else
  1104.                                                                                              {
  1105.                                                                                                 if(eval("\x01") == 666)
  1106.                                                                                                 {
  1107.                                                                                                    set("\x01",eval("\x01") - 317);
  1108.                                                                                                    break loop0;
  1109.                                                                                                 }
  1110.                                                                                                 if(eval("\x01") == 625)
  1111.                                                                                                 {
  1112.                                                                                                    set("\x01",eval("\x01") - 516);
  1113.                                                                                                    if(┬º┬ºpop())
  1114.                                                                                                    {
  1115.                                                                                                       set("\x01",eval("\x01") + 257);
  1116.                                                                                                    }
  1117.                                                                                                 }
  1118.                                                                                                 else if(eval("\x01") == 246)
  1119.                                                                                                 {
  1120.                                                                                                    set("\x01",eval("\x01") + 420);
  1121.                                                                                                    if(┬º┬ºpop())
  1122.                                                                                                    {
  1123.                                                                                                       set("\x01",eval("\x01") - 317);
  1124.                                                                                                    }
  1125.                                                                                                 }
  1126.                                                                                                 else
  1127.                                                                                                 {
  1128.                                                                                                    if(eval("\x01") == 841)
  1129.                                                                                                    {
  1130.                                                                                                       set("\x01",eval("\x01") - 385);
  1131.                                                                                                       break loop0;
  1132.                                                                                                    }
  1133.                                                                                                    if(eval("\x01") == 932)
  1134.                                                                                                    {
  1135.                                                                                                       break loop7;
  1136.                                                                                                    }
  1137.                                                                                                    if(eval("\x01") == 198)
  1138.                                                                                                    {
  1139.                                                                                                       set("\x01",eval("\x01") + 290);
  1140.                                                                                                    }
  1141.                                                                                                    else if(eval("\x01") == 488)
  1142.                                                                                                    {
  1143.                                                                                                       set("\x01",eval("\x01") + 367);
  1144.                                                                                                    }
  1145.                                                                                                    else if(eval("\x01") == 378)
  1146.                                                                                                    {
  1147.                                                                                                       set("\x01",eval("\x01") - 350);
  1148.                                                                                                    }
  1149.                                                                                                    else if(eval("\x01") == 297)
  1150.                                                                                                    {
  1151.                                                                                                       set("\x01",eval("\x01") - 269);
  1152.                                                                                                    }
  1153.                                                                                                    else
  1154.                                                                                                    {
  1155.                                                                                                       if(eval("\x01") == 836)
  1156.                                                                                                       {
  1157.                                                                                                          set("\x01",eval("\x01") - 836);
  1158.                                                                                                          break loop0;
  1159.                                                                                                       }
  1160.                                                                                                       if(eval("\x01") != 89)
  1161.                                                                                                       {
  1162.                                                                                                          break loop0;
  1163.                                                                                                       }
  1164.                                                                                                       set("\x01",eval("\x01") + 550);
  1165.                                                                                                    }
  1166.                                                                                                 }
  1167.                                                                                              }
  1168.                                                                                           }
  1169.                                                                                        }
  1170.                                                                                     }
  1171.                                                                                     continue;
  1172.                                                                                  }
  1173.                                                                                  set("\x01",eval("\x01") + 87);
  1174.                                                                                  while(true)
  1175.                                                                                  {
  1176.                                                                                     if(┬º┬ºpop() == ┬º┬ºpop())
  1177.                                                                                     {
  1178.                                                                                        set("\x01",eval("\x01") + 79);
  1179.                                                                                     }
  1180.                                                                                     else if(eval("\x01") == 312)
  1181.                                                                                     {
  1182.                                                                                        set("\x01",eval("\x01") + 673);
  1183.                                                                                     }
  1184.                                                                                     else if(eval("\x01") == 171)
  1185.                                                                                     {
  1186.                                                                                        set("\x01",eval("\x01") + 300);
  1187.                                                                                     }
  1188.                                                                                     else if(eval("\x01") == 563)
  1189.                                                                                     {
  1190.                                                                                        set("\x01",eval("\x01") - 477);
  1191.                                                                                        if(┬º┬ºpop())
  1192.                                                                                        {
  1193.                                                                                           set("\x01",eval("\x01") + 210);
  1194.                                                                                        }
  1195.                                                                                     }
  1196.                                                                                     else
  1197.                                                                                     {
  1198.                                                                                        if(eval("\x01") == 86)
  1199.                                                                                        {
  1200.                                                                                           set("\x01",eval("\x01") + 210);
  1201.                                                                                           ┬º┬ºpush(eval(┬º┬ºpop()));
  1202.                                                                                           break loop0;
  1203.                                                                                        }
  1204.                                                                                        if(eval("\x01") == 40)
  1205.                                                                                        {
  1206.                                                                                           set("\x01",eval("\x01") - 3);
  1207.                                                                                        }
  1208.                                                                                        else if(eval("\x01") == 471)
  1209.                                                                                        {
  1210.                                                                                           set("\x01",eval("\x01") - 8);
  1211.                                                                                           ┬º┬ºpush(true);
  1212.                                                                                        }
  1213.                                                                                        else
  1214.                                                                                        {
  1215.                                                                                           if(eval("\x01") != 575)
  1216.                                                                                           {
  1217.                                                                                              if(eval("\x01") == 313)
  1218.                                                                                              {
  1219.                                                                                                 addr1228:
  1220.                                                                                                 set("\x01",eval("\x01") - 313);
  1221.                                                                                                 break loop0;
  1222.                                                                                              }
  1223.                                                                                              break loop0;
  1224.                                                                                           }
  1225.                                                                                           set("\x01",eval("\x01") + 410);
  1226.                                                                                        }
  1227.                                                                                     }
  1228.                                                                                     while(true)
  1229.                                                                                     {
  1230.                                                                                        if(eval("\x01") == 915)
  1231.                                                                                        {
  1232.                                                                                           set("\x01",eval("\x01") - 196);
  1233.                                                                                           ┬º┬ºpush(true);
  1234.                                                                                        }
  1235.                                                                                        else
  1236.                                                                                        {
  1237.                                                                                           if(eval("\x01") == 330)
  1238.                                                                                           {
  1239.                                                                                              set("\x01",eval("\x01") + 317);
  1240.                                                                                              break loop0;
  1241.                                                                                           }
  1242.                                                                                           if(eval("\x01") == 714)
  1243.                                                                                           {
  1244.                                                                                              set("\x01",eval("\x01") - 384);
  1245.                                                                                              if(┬º┬ºpop())
  1246.                                                                                              {
  1247.                                                                                                 set("\x01",eval("\x01") + 317);
  1248.                                                                                              }
  1249.                                                                                           }
  1250.                                                                                           else if(eval("\x01") == 719)
  1251.                                                                                           {
  1252.                                                                                              set("\x01",eval("\x01") + 225);
  1253.                                                                                              if(┬º┬ºpop())
  1254.                                                                                              {
  1255.                                                                                                 set("\x01",eval("\x01") - 484);
  1256.                                                                                              }
  1257.                                                                                           }
  1258.                                                                                           else if(eval("\x01") == 647)
  1259.                                                                                           {
  1260.                                                                                              set("\x01",eval("\x01") - 176);
  1261.                                                                                           }
  1262.                                                                                           else
  1263.                                                                                           {
  1264.                                                                                              if(eval("\x01") == 511)
  1265.                                                                                              {
  1266.                                                                                                 set("\x01",eval("\x01") + 351);
  1267.                                                                                                 break loop0;
  1268.                                                                                              }
  1269.                                                                                              if(eval("\x01") == 944)
  1270.                                                                                              {
  1271.                                                                                                 set("\x01",eval("\x01") - 484);
  1272.                                                                                                 ifFrameLoaded(┬º┬ºpop())
  1273.                                                                                                 {
  1274.                                                                                                 }
  1275.                                                                                              }
  1276.                                                                                              if(eval("\x01") == 37)
  1277.                                                                                              {
  1278.                                                                                                 set("\x01",eval("\x01") + 677);
  1279.                                                                                                 ┬º┬ºpush(true);
  1280.                                                                                              }
  1281.                                                                                              else if(eval("\x01") == 942)
  1282.                                                                                              {
  1283.                                                                                                 set("\x01",eval("\x01") - 379);
  1284.                                                                                                 ┬º┬ºpush(true);
  1285.                                                                                              }
  1286.                                                                                              else if(eval("\x01") == 337)
  1287.                                                                                              {
  1288.                                                                                                 set("\x01",eval("\x01") + 605);
  1289.                                                                                              }
  1290.                                                                                              else if(eval("\x01") == 862)
  1291.                                                                                              {
  1292.                                                                                                 set("\x01",eval("\x01") + 80);
  1293.                                                                                              }
  1294.                                                                                              else if(eval("\x01") == 539)
  1295.                                                                                              {
  1296.                                                                                                 set("\x01",eval("\x01") - 320);
  1297.                                                                                                 ┬º┬ºpush(true);
  1298.                                                                                              }
  1299.                                                                                              else
  1300.                                                                                              {
  1301.                                                                                                 if(eval("\x01") == 985)
  1302.                                                                                                 {
  1303.                                                                                                    set("\x01",eval("\x01") - 672);
  1304.                                                                                                    nextFrame();
  1305.                                                                                                    _parent.gotoAndPlay("newround");
  1306.                                                                                                    break loop0;
  1307.                                                                                                 }
  1308.                                                                                                 if(eval("\x01") == 219)
  1309.                                                                                                 {
  1310.                                                                                                    set("\x01",eval("\x01") + 292);
  1311.                                                                                                    if(┬º┬ºpop())
  1312.                                                                                                    {
  1313.                                                                                                       set("\x01",eval("\x01") + 351);
  1314.                                                                                                    }
  1315.                                                                                                 }
  1316.                                                                                                 else if(eval("\x01") == 174)
  1317.                                                                                                 {
  1318.                                                                                                    set("\x01",eval("\x01") + 365);
  1319.                                                                                                 }
  1320.                                                                                                 else
  1321.                                                                                                 {
  1322.                                                                                                    if(eval("\x01") == 683)
  1323.                                                                                                    {
  1324.                                                                                                       set("\x01",eval("\x01") - 371);
  1325.                                                                                                       ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  1326.                                                                                                       break loop0;
  1327.                                                                                                    }
  1328.                                                                                                    if(eval("\x01") == 463)
  1329.                                                                                                    {
  1330.                                                                                                       set("\x01",eval("\x01") + 220);
  1331.                                                                                                       if(┬º┬ºpop())
  1332.                                                                                                       {
  1333.                                                                                                          set("\x01",eval("\x01") - 371);
  1334.                                                                                                       }
  1335.                                                                                                    }
  1336.                                                                                                    else
  1337.                                                                                                    {
  1338.                                                                                                       if(eval("\x01") != 296)
  1339.                                                                                                       {
  1340.                                                                                                          break;
  1341.                                                                                                       }
  1342.                                                                                                       set("\x01",eval("\x01") - 259);
  1343.                                                                                                    }
  1344.                                                                                                 }
  1345.                                                                                              }
  1346.                                                                                           }
  1347.                                                                                        }
  1348.                                                                                     }
  1349.                                                                                  }
  1350.                                                                               }
  1351.                                                                               set("\x01",eval("\x01") + 6);
  1352.                                                                            }
  1353.                                                                            set("\x01",eval("\x01") - 554);
  1354.                                                                            ┬º┬ºenumerate(┬º┬ºpop() - (┬º┬ºpop() instanceof ┬º┬ºpop()));
  1355.                                                                            break loop0;
  1356.                                                                         }
  1357.                                                                         if(eval("\x01") == 245)
  1358.                                                                         {
  1359.                                                                            set("\x01",eval("\x01") + 719);
  1360.                                                                         }
  1361.                                                                         else
  1362.                                                                         {
  1363.                                                                            if(eval("\x01") == 180)
  1364.                                                                            {
  1365.                                                                               set("\x01",eval("\x01") + 280);
  1366.                                                                               break loop0;
  1367.                                                                            }
  1368.                                                                            if(eval("\x01") == 964)
  1369.                                                                            {
  1370.                                                                               set("\x01",eval("\x01") - 825);
  1371.                                                                               ┬º┬ºpush(true);
  1372.                                                                            }
  1373.                                                                            else
  1374.                                                                            {
  1375.                                                                               if(eval("\x01") != 429)
  1376.                                                                               {
  1377.                                                                                  break loop0;
  1378.                                                                               }
  1379.                                                                               set("\x01",eval("\x01") + 535);
  1380.                                                                            }
  1381.                                                                         }
  1382.                                                                      }
  1383.                                                                   }
  1384.                                                                }
  1385.                                                             }
  1386.                                                          }
  1387.                                                       }
  1388.                                                    }
  1389.                                                    continue;
  1390.                                                 }
  1391.                                                 set("\x01",eval("\x01") + 41);
  1392.                                                 ┬º┬ºpush(String(┬º┬ºpop() >>> ┬º┬ºpop()));
  1393.                                                 while(true)
  1394.                                                 {
  1395.                                                    if(┬º┬ºpop() == ┬º┬ºpop())
  1396.                                                    {
  1397.                                                       set("\x01",eval("\x01") + 269);
  1398.                                                       loop13:
  1399.                                                       while(true)
  1400.                                                       {
  1401.                                                          if(eval("\x01") == 737)
  1402.                                                          {
  1403.                                                             set("\x01",eval("\x01") - 644);
  1404.                                                             ┬º┬ºpush(true);
  1405.                                                             continue;
  1406.                                                          }
  1407.                                                          if(eval("\x01") == 356)
  1408.                                                          {
  1409.                                                             break;
  1410.                                                          }
  1411.                                                          if(eval("\x01") == 2)
  1412.                                                          {
  1413.                                                             set("\x01",eval("\x01") + 456);
  1414.                                                             break loop0;
  1415.                                                          }
  1416.                                                          if(eval("\x01") == 497)
  1417.                                                          {
  1418.                                                             set("\x01",eval("\x01") + 16);
  1419.                                                             if(┬º┬ºpop())
  1420.                                                             {
  1421.                                                                set("\x01",eval("\x01") - 317);
  1422.                                                             }
  1423.                                                             continue;
  1424.                                                          }
  1425.                                                          if(eval("\x01") == 231)
  1426.                                                          {
  1427.                                                             set("\x01",eval("\x01") + 295);
  1428.                                                             continue;
  1429.                                                          }
  1430.                                                          if(eval("\x01") == 320)
  1431.                                                          {
  1432.                                                             set("\x01",eval("\x01") + 296);
  1433.                                                             break loop0;
  1434.                                                          }
  1435.                                                          if(eval("\x01") == 30)
  1436.                                                          {
  1437.                                                             ┬º┬ºpush("\x01");
  1438.                                                             ┬º┬ºpush(eval("\x01") + 201);
  1439.                                                          }
  1440.                                                          else
  1441.                                                          {
  1442.                                                             if(eval("\x01") == 992)
  1443.                                                             {
  1444.                                                                set("\x01",eval("\x01") - 41);
  1445.                                                                continue;
  1446.                                                             }
  1447.                                                             if(eval("\x01") == 616)
  1448.                                                             {
  1449.                                                                set("\x01",eval("\x01") + 94);
  1450.                                                                continue;
  1451.                                                             }
  1452.                                                             if(eval("\x01") == 261)
  1453.                                                             {
  1454.                                                                set("\x01",eval("\x01") + 95);
  1455.                                                                if(┬º┬ºpop())
  1456.                                                                {
  1457.                                                                   set("\x01",eval("\x01") + 72);
  1458.                                                                }
  1459.                                                                continue;
  1460.                                                             }
  1461.                                                             if(eval("\x01") == 126)
  1462.                                                             {
  1463.                                                                set("\x01",eval("\x01") + 48);
  1464.                                                                continue;
  1465.                                                             }
  1466.                                                             if(eval("\x01") != 951)
  1467.                                                             {
  1468.                                                                if(eval("\x01") == 428)
  1469.                                                                {
  1470.                                                                   set("\x01",eval("\x01") - 223);
  1471.                                                                }
  1472.                                                                else if(eval("\x01") == 458)
  1473.                                                                {
  1474.                                                                   set("\x01",eval("\x01") + 28);
  1475.                                                                }
  1476.                                                                else if(eval("\x01") == 339)
  1477.                                                                {
  1478.                                                                   set("\x01",eval("\x01") + 583);
  1479.                                                                   if(┬º┬ºpop())
  1480.                                                                   {
  1481.                                                                      set("\x01",eval("\x01") - 241);
  1482.                                                                   }
  1483.                                                                }
  1484.                                                                else
  1485.                                                                {
  1486.                                                                   if(eval("\x01") == 370)
  1487.                                                                   {
  1488.                                                                      set("\x01",eval("\x01") - 244);
  1489.                                                                      addr771:
  1490.                                                                      ┬º┬ºpush(mbord(┬º┬ºpop()));
  1491.                                                                      break loop0;
  1492.                                                                   }
  1493.                                                                   if(eval("\x01") == 433)
  1494.                                                                   {
  1495.                                                                      set("\x01",eval("\x01") - 259);
  1496.                                                                   }
  1497.                                                                   else if(eval("\x01") == 36)
  1498.                                                                   {
  1499.                                                                      set("\x01",eval("\x01") - 6);
  1500.                                                                      if(┬º┬ºpop())
  1501.                                                                      {
  1502.                                                                         set("\x01",eval("\x01") + 201);
  1503.                                                                      }
  1504.                                                                   }
  1505.                                                                   else if(eval("\x01") == 174)
  1506.                                                                   {
  1507.                                                                      set("\x01",eval("\x01") - 138);
  1508.                                                                      ┬º┬ºpush(true);
  1509.                                                                   }
  1510.                                                                   else if(eval("\x01") == 104)
  1511.                                                                   {
  1512.                                                                      set("\x01",eval("\x01") + 265);
  1513.                                                                      if(┬º┬ºpop())
  1514.                                                                      {
  1515.                                                                         set("\x01",eval("\x01") - 29);
  1516.                                                                      }
  1517.                                                                   }
  1518.                                                                   else if(eval("\x01") == 941)
  1519.                                                                   {
  1520.                                                                      set("\x01",eval("\x01") - 808);
  1521.                                                                      ┬º┬ºpush(true);
  1522.                                                                   }
  1523.                                                                   else if(eval("\x01") == 666)
  1524.                                                                   {
  1525.                                                                      set("\x01",eval("\x01") - 140);
  1526.                                                                   }
  1527.                                                                   else if(eval("\x01") == 237)
  1528.                                                                   {
  1529.                                                                      set("\x01",eval("\x01") - 235);
  1530.                                                                      if(┬º┬ºpop())
  1531.                                                                      {
  1532.                                                                         set("\x01",eval("\x01") + 456);
  1533.                                                                      }
  1534.                                                                   }
  1535.                                                                   else if(eval("\x01") == 284)
  1536.                                                                   {
  1537.                                                                      set("\x01",eval("\x01") + 426);
  1538.                                                                   }
  1539.                                                                   else if(eval("\x01") == 520)
  1540.                                                                   {
  1541.                                                                      set("\x01",eval("\x01") + 421);
  1542.                                                                   }
  1543.                                                                   else if(eval("\x01") == 205)
  1544.                                                                   {
  1545.                                                                      set("\x01",eval("\x01") + 292);
  1546.                                                                      ┬º┬ºpush(true);
  1547.                                                                   }
  1548.                                                                   else if(eval("\x01") == 197)
  1549.                                                                   {
  1550.                                                                      set("\x01",eval("\x01") + 778);
  1551.                                                                   }
  1552.                                                                   else if(eval("\x01") == 556)
  1553.                                                                   {
  1554.                                                                      set("\x01",eval("\x01") - 351);
  1555.                                                                   }
  1556.                                                                   else if(eval("\x01") == 710)
  1557.                                                                   {
  1558.                                                                      set("\x01",eval("\x01") - 473);
  1559.                                                                      ┬º┬ºpush(true);
  1560.                                                                   }
  1561.                                                                   else if(eval("\x01") == 526)
  1562.                                                                   {
  1563.                                                                      set("\x01",eval("\x01") - 265);
  1564.                                                                      ┬º┬ºpush(true);
  1565.                                                                   }
  1566.                                                                   else if(eval("\x01") == 93)
  1567.                                                                   {
  1568.                                                                      set("\x01",eval("\x01") + 277);
  1569.                                                                      if(┬º┬ºpop())
  1570.                                                                      {
  1571.                                                                         set("\x01",eval("\x01") - 244);
  1572.                                                                      }
  1573.                                                                   }
  1574.                                                                   else if(eval("\x01") == 977)
  1575.                                                                   {
  1576.                                                                      set("\x01",eval("\x01") - 491);
  1577.                                                                   }
  1578.                                                                   else if(eval("\x01") == 133)
  1579.                                                                   {
  1580.                                                                      set("\x01",eval("\x01") + 187);
  1581.                                                                      if(┬º┬ºpop())
  1582.                                                                      {
  1583.                                                                         set("\x01",eval("\x01") + 296);
  1584.                                                                      }
  1585.                                                                   }
  1586.                                                                   else
  1587.                                                                   {
  1588.                                                                      if(eval("\x01") == 369)
  1589.                                                                      {
  1590.                                                                         set("\x01",eval("\x01") - 29);
  1591.                                                                         ┬º┬ºpush(new ┬º\┬º\┬ºpop()┬º());
  1592.                                                                         break loop0;
  1593.                                                                      }
  1594.                                                                      if(eval("\x01") == 975)
  1595.                                                                      {
  1596.                                                                         set("\x01",eval("\x01") - 747);
  1597.                                                                         ┬º┬ºpush(true);
  1598.                                                                      }
  1599.                                                                      else if(eval("\x01") == 681)
  1600.                                                                      {
  1601.                                                                         set("\x01",eval("\x01") + 294);
  1602.                                                                      }
  1603.                                                                      else
  1604.                                                                      {
  1605.                                                                         if(eval("\x01") == 513)
  1606.                                                                         {
  1607.                                                                            set("\x01",eval("\x01") - 317);
  1608.                                                                            ifFrameLoaded(┬º┬ºpop())
  1609.                                                                            {
  1610.                                                                               getTimer();
  1611.                                                                            }
  1612.                                                                         }
  1613.                                                                         if(eval("\x01") == 196)
  1614.                                                                         {
  1615.                                                                            set("\x01",eval("\x01") + 755);
  1616.                                                                         }
  1617.                                                                         else if(eval("\x01") == 835)
  1618.                                                                         {
  1619.                                                                            set("\x01",eval("\x01") - 526);
  1620.                                                                         }
  1621.                                                                         else
  1622.                                                                         {
  1623.                                                                            if(eval("\x01") == 922)
  1624.                                                                            {
  1625.                                                                               set("\x01",eval("\x01") - 241);
  1626.                                                                               ┬º┬ºpush(┬º┬ºpop()[┬º┬ºpop() << ┬º┬ºpop()]() + 1 - 1);
  1627.                                                                               break loop0;
  1628.                                                                            }
  1629.                                                                            if(eval("\x01") == 228)
  1630.                                                                            {
  1631.                                                                               set("\x01",eval("\x01") + 62);
  1632.                                                                               if(┬º┬ºpop())
  1633.                                                                               {
  1634.                                                                                  set("\x01",eval("\x01") + 451);
  1635.                                                                               }
  1636.                                                                            }
  1637.                                                                            else
  1638.                                                                            {
  1639.                                                                               if(eval("\x01") == 486)
  1640.                                                                               {
  1641.                                                                                  set("\x01",eval("\x01") - 12);
  1642.                                                                                  prevFrame();
  1643.                                                                                  break loop0;
  1644.                                                                               }
  1645.                                                                               if(eval("\x01") == 290)
  1646.                                                                               {
  1647.                                                                                  set("\x01",eval("\x01") + 451);
  1648.                                                                                  stop();
  1649.                                                                                  ┬º┬ºpush(!┬º┬ºpop());
  1650.                                                                                  break loop0;
  1651.                                                                               }
  1652.                                                                               if(eval("\x01") == 474)
  1653.                                                                               {
  1654.                                                                                  set("\x01",eval("\x01") - 474);
  1655.                                                                                  break loop0;
  1656.                                                                               }
  1657.                                                                               if(eval("\x01") == 741)
  1658.                                                                               {
  1659.                                                                                  set("\x01",eval("\x01") - 432);
  1660.                                                                               }
  1661.                                                                               else if(eval("\x01") == 309)
  1662.                                                                               {
  1663.                                                                                  set("\x01",eval("\x01") - 205);
  1664.                                                                                  ┬º┬ºpush(true);
  1665.                                                                               }
  1666.                                                                               else
  1667.                                                                               {
  1668.                                                                                  if(eval("\x01") != 340)
  1669.                                                                                  {
  1670.                                                                                     break loop0;
  1671.                                                                                  }
  1672.                                                                                  set("\x01",eval("\x01") + 601);
  1673.                                                                               }
  1674.                                                                            }
  1675.                                                                         }
  1676.                                                                      }
  1677.                                                                   }
  1678.                                                                }
  1679.                                                                continue;
  1680.                                                             }
  1681.                                                             while(true)
  1682.                                                             {
  1683.                                                                set("\x01",eval("\x01") - 612);
  1684.                                                                continue loop13;
  1685.                                                             }
  1686.                                                          }
  1687.                                                       }
  1688.                                                       set("\x01",eval("\x01") + 72);
  1689.                                                       duplicateMovieClip(┬º┬ºpop(),┬º┬ºpop(),┬º┬ºpop().substr(┬º┬ºpop(),┬º┬ºpop()));
  1690.                                                       return ┬º┬ºpop();
  1691.                                                       addr2081:
  1692.                                                    }
  1693.                                                    if(eval("\x01") == 461)
  1694.                                                    {
  1695.                                                       set("\x01",eval("\x01") + 223);
  1696.                                                       if(┬º┬ºpop())
  1697.                                                       {
  1698.                                                          set("\x01",eval("\x01") + 269);
  1699.                                                       }
  1700.                                                       continue;
  1701.                                                       set("\x01",eval("\x01") + 195);
  1702.                                                    }
  1703.                                                    if(eval("\x01") == 700)
  1704.                                                    {
  1705.                                                       set("\x01",eval("\x01") - 359);
  1706.                                                       break loop0;
  1707.                                                    }
  1708.                                                    if(eval("\x01") == 32)
  1709.                                                    {
  1710.                                                       set("\x01",eval("\x01") + 120);
  1711.                                                       getUrl("3\x13\x05∩┐╜∩┐╜M∩┐╜eSZ\x1e∩┐╜∩┐╜k∩┐╜`S∩┐╜", "\x01");
  1712.                                                       break loop0;
  1713.                                                    }
  1714.                                                    if(eval("\x01") != 835)
  1715.                                                    {
  1716.                                                       if(eval("\x01") == 341)
  1717.                                                       {
  1718.                                                          set("\x01",eval("\x01") + 244);
  1719.                                                          continue;
  1720.                                                          continue;
  1721.                                                       }
  1722.                                                       if(eval("\x01") == 832)
  1723.                                                       {
  1724.                                                          set("\x01",eval("\x01") - 800);
  1725.                                                          if(┬º┬ºpop())
  1726.                                                          {
  1727.                                                             set("\x01",eval("\x01") + 120);
  1728.                                                          }
  1729.                                                          continue;
  1730.                                                       }
  1731.                                                       if(eval("\x01") == 201)
  1732.                                                       {
  1733.                                                          set("\x01",eval("\x01") + 106);
  1734.                                                          continue;
  1735.                                                       }
  1736.                                                       if(eval("\x01") == 103)
  1737.                                                       {
  1738.                                                          set("\x01",eval("\x01") + 597);
  1739.                                                          if(┬º┬ºpop())
  1740.                                                          {
  1741.                                                             set("\x01",eval("\x01") - 359);
  1742.                                                          }
  1743.                                                          continue;
  1744.                                                       }
  1745.                                                       if(eval("\x01") != 743)
  1746.                                                       {
  1747.                                                          if(eval("\x01") == 938)
  1748.                                                          {
  1749.                                                             set("\x01",eval("\x01") - 476);
  1750.                                                             _parent.blue.gotoAndStop(2);
  1751.                                                             play();
  1752.                                                             break loop0;
  1753.                                                          }
  1754.                                                          if(eval("\x01") == 237)
  1755.                                                          {
  1756.                                                             set("\x01",eval("\x01") - 24);
  1757.                                                             if(┬º┬ºpop())
  1758.                                                             {
  1759.                                                                set("\x01",eval("\x01") - 156);
  1760.                                                             }
  1761.                                                             continue;
  1762.                                                             continue;
  1763.                                                          }
  1764.                                                          if(eval("\x01") != 339)
  1765.                                                          {
  1766.                                                             if(eval("\x01") != 307)
  1767.                                                             {
  1768.                                                                if(eval("\x01") == 213)
  1769.                                                                {
  1770.                                                                   set("\x01",eval("\x01") - 156);
  1771.                                                                   break loop0;
  1772.                                                                }
  1773.                                                                if(eval("\x01") == 797)
  1774.                                                                {
  1775.                                                                   set("\x01",eval("\x01") - 458);
  1776.                                                                   continue;
  1777.                                                                   continue;
  1778.                                                                }
  1779.                                                                if(eval("\x01") == 298)
  1780.                                                                {
  1781.                                                                   set("\x01",eval("\x01") - 61);
  1782.                                                                   ┬º┬ºpush(true);
  1783.                                                                   continue;
  1784.                                                                }
  1785.                                                                if(eval("\x01") == 660)
  1786.                                                                {
  1787.                                                                   set("\x01",eval("\x01") - 362);
  1788.                                                                   continue;
  1789.                                                                }
  1790.                                                                if(eval("\x01") != 862)
  1791.                                                                {
  1792.                                                                   if(eval("\x01") == 986)
  1793.                                                                   {
  1794.                                                                      set("\x01",eval("\x01") - 326);
  1795.                                                                      break loop0;
  1796.                                                                   }
  1797.                                                                   if(eval("\x01") != 585)
  1798.                                                                   {
  1799.                                                                      if(eval("\x01") != 666)
  1800.                                                                      {
  1801.                                                                         if(eval("\x01") != 449)
  1802.                                                                         {
  1803.                                                                            if(eval("\x01") == 8)
  1804.                                                                            {
  1805.                                                                               set("\x01",eval("\x01") + 735);
  1806.                                                                               ┬º┬ºpush(┬º┬ºpop() % ┬º┬ºpop());
  1807.                                                                               break loop0;
  1808.                                                                            }
  1809.                                                                            if(eval("\x01") == 462)
  1810.                                                                            {
  1811.                                                                               set("\x01",eval("\x01") - 462);
  1812.                                                                               break loop0;
  1813.                                                                            }
  1814.                                                                         }
  1815.                                                                         set("\x01",eval("\x01") + 489);
  1816.                                                                         continue;
  1817.                                                                      }
  1818.                                                                      set("\x01",eval("\x01") - 658);
  1819.                                                                      if(┬º┬ºpop())
  1820.                                                                      {
  1821.                                                                         set("\x01",eval("\x01") + 735);
  1822.                                                                      }
  1823.                                                                   }
  1824.                                                                   set("\x01",eval("\x01") + 81);
  1825.                                                                   ┬º┬ºpush(true);
  1826.                                                                }
  1827.                                                             }
  1828.                                                             set("\x01",eval("\x01") + 525);
  1829.                                                             ┬º┬ºpush(true);
  1830.                                                             continue;
  1831.                                                             set("\x01",eval("\x01") - 277);
  1832.                                                          }
  1833.                                                          set("\x01",eval("\x01") - 236);
  1834.                                                          ┬º┬ºpush(true);
  1835.                                                       }
  1836.                                                    }
  1837.                                                    set("\x01",eval("\x01") - 374);
  1838.                                                    ┬º┬ºpush(true);
  1839.                                                 }
  1840.                                              }
  1841.                                              set(┬º┬ºpop(),┬º┬ºpop());
  1842.                                              ┬º┬ºpush(length(┬º┬ºpop() / ┬º┬ºpop()));
  1843.                                           }
  1844.                                           set("\x01",eval("\x01") + 682);
  1845.                                           if(┬º┬ºpop())
  1846.                                           {
  1847.                                              set("\x01",eval("\x01") - 716);
  1848.                                           }
  1849.                                        }
  1850.                                        set("\x01",eval("\x01") + 356);
  1851.                                        continue;
  1852.                                     }
  1853.                                     set("\x01",eval("\x01") - 33);
  1854.                                     continue;
  1855.                                  }
  1856.                                  set("\x01",eval("\x01") + 745);
  1857.                                  continue;
  1858.                               }
  1859.                               set("\x01",eval("\x01") + 617);
  1860.                               continue;
  1861.                            }
  1862.                            set("\x01",eval("\x01") - 431);
  1863.                            ┬º┬ºpush(true);
  1864.                         }
  1865.                      }
  1866.                   }
  1867.                   set("\x01",eval("\x01") - 55);
  1868.                }
  1869.                set("\x01",eval("\x01") - 325);
  1870.                ifFrameLoaded(82)
  1871.                {
  1872.                   var ┬º┬ºpop() = ┬º┬ºpop();
  1873.                }
  1874.                ┬º┬ºpush("\x01");
  1875.                ┬º┬ºpush("\x01");
  1876.             }
  1877.             else
  1878.             {
  1879.                if(eval("\x01") == 216)
  1880.                {
  1881.                   set("\x01",eval("\x01") + 322);
  1882.                   continue;
  1883.                }
  1884.                if(eval("\x01") == 505)
  1885.                {
  1886.                   set("\x01",eval("\x01") + 94);
  1887.                   nextFrame();
  1888.                   loop4:
  1889.                   while(true)
  1890.                   {
  1891.                      while(true)
  1892.                      {
  1893.                         if(eval("\x01") != 179)
  1894.                         {
  1895.                            if(eval("\x01") != 679)
  1896.                            {
  1897.                               if(eval("\x01") != 510)
  1898.                               {
  1899.                                  if(eval("\x01") != 535)
  1900.                                  {
  1901.                                     if(eval("\x01") != 529)
  1902.                                     {
  1903.                                        if(eval("\x01") == 396)
  1904.                                        {
  1905.                                           set("\x01",eval("\x01") - 308);
  1906.                                        }
  1907.                                        else
  1908.                                        {
  1909.                                           if(eval("\x01") == 16)
  1910.                                           {
  1911.                                              set("\x01",eval("\x01") + 758);
  1912.                                              ┬º┬ºpush(true);
  1913.                                              continue;
  1914.                                           }
  1915.                                           if(eval("\x01") == 774)
  1916.                                           {
  1917.                                              set("\x01",eval("\x01") - 378);
  1918.                                              if(┬º┬ºpop())
  1919.                                              {
  1920.                                                 set("\x01",eval("\x01") - 308);
  1921.                                              }
  1922.                                              continue;
  1923.                                           }
  1924.                                           if(eval("\x01") == 45)
  1925.                                           {
  1926.                                              set("\x01",eval("\x01") + 176);
  1927.                                              if(┬º┬ºpop())
  1928.                                              {
  1929.                                                 set("\x01",eval("\x01") + 314);
  1930.                                              }
  1931.                                              continue;
  1932.                                           }
  1933.                                           if(eval("\x01") == 939)
  1934.                                           {
  1935.                                              set("\x01",eval("\x01") - 801);
  1936.                                              if(┬º┬ºpop())
  1937.                                              {
  1938.                                                 set("\x01",eval("\x01") + 796);
  1939.                                              }
  1940.                                              continue;
  1941.                                           }
  1942.                                           if(eval("\x01") == 759)
  1943.                                           {
  1944.                                              set("\x01",eval("\x01") + 180);
  1945.                                              ┬º┬ºpush(true);
  1946.                                              continue;
  1947.                                           }
  1948.                                           if(eval("\x01") == 223)
  1949.                                           {
  1950.                                              set("\x01",eval("\x01") - 207);
  1951.                                              continue;
  1952.                                           }
  1953.                                           if(eval("\x01") == 291)
  1954.                                           {
  1955.                                              set("\x01",eval("\x01") - 68);
  1956.                                              ┬º┬ºpush(┬º┬ºpop() >>> ┬º┬ºpop());
  1957.                                              break loop0;
  1958.                                           }
  1959.                                           if(eval("\x01") == 601)
  1960.                                           {
  1961.                                              set("\x01",eval("\x01") - 585);
  1962.                                              continue;
  1963.                                           }
  1964.                                           if(eval("\x01") == 697)
  1965.                                           {
  1966.                                              set("\x01",eval("\x01") - 116);
  1967.                                              continue;
  1968.                                           }
  1969.                                           if(eval("\x01") == 221)
  1970.                                           {
  1971.                                              set("\x01",eval("\x01") + 314);
  1972.                                              var ┬º┬ºpop() and ┬º┬ºpop();
  1973.                                           }
  1974.                                           else
  1975.                                           {
  1976.                                              if(eval("\x01") == 463)
  1977.                                              {
  1978.                                                 set("\x01",eval("\x01") - 172);
  1979.                                                 if(┬º┬ºpop())
  1980.                                                 {
  1981.                                                    set("\x01",eval("\x01") - 68);
  1982.                                                 }
  1983.                                                 continue;
  1984.                                              }
  1985.                                              if(eval("\x01") == 138)
  1986.                                              {
  1987.                                                 set("\x01",eval("\x01") + 796);
  1988.                                                 ┬º┬ºpush(Number(┬º┬ºpop()));
  1989.                                                 break loop0;
  1990.                                              }
  1991.                                              if(eval("\x01") == 88)
  1992.                                              {
  1993.                                                 set("\x01",eval("\x01") + 591);
  1994.                                                 continue;
  1995.                                              }
  1996.                                              if(eval("\x01") == 737)
  1997.                                              {
  1998.                                                 set("\x01",eval("\x01") - 58);
  1999.                                                 continue;
  2000.                                              }
  2001.                                              if(eval("\x01") == 735)
  2002.                                              {
  2003.                                                 set("\x01",eval("\x01") - 626);
  2004.                                                 continue;
  2005.                                              }
  2006.                                              if(eval("\x01") == 803)
  2007.                                              {
  2008.                                                 set("\x01",eval("\x01") - 438);
  2009.                                                 if(┬º┬ºpop())
  2010.                                                 {
  2011.                                                    set("\x01",eval("\x01") + 241);
  2012.                                                 }
  2013.                                                 continue;
  2014.                                              }
  2015.                                              if(eval("\x01") == 132)
  2016.                                              {
  2017.                                                 set("\x01",eval("\x01") - 23);
  2018.                                                 continue;
  2019.                                              }
  2020.                                              if(eval("\x01") != 431)
  2021.                                              {
  2022.                                                 if(eval("\x01") == 365)
  2023.                                                 {
  2024.                                                    break loop4;
  2025.                                                 }
  2026.                                                 if(eval("\x01") == 606)
  2027.                                                 {
  2028.                                                    set("\x01",eval("\x01") - 25);
  2029.                                                 }
  2030.                                                 else if(eval("\x01") == 934)
  2031.                                                 {
  2032.                                                    set("\x01",eval("\x01") - 601);
  2033.                                                 }
  2034.                                                 else if(eval("\x01") == 753)
  2035.                                                 {
  2036.                                                    set("\x01",eval("\x01") - 420);
  2037.                                                 }
  2038.                                                 else
  2039.                                                 {
  2040.                                                    if(eval("\x01") == 109)
  2041.                                                    {
  2042.                                                       break;
  2043.                                                    }
  2044.                                                    if(eval("\x01") == 581)
  2045.                                                    {
  2046.                                                       set("\x01",eval("\x01") - 257);
  2047.                                                       _parent.yellow.gotoAndStop(1);
  2048.                                                       break loop0;
  2049.                                                    }
  2050.                                                    if(eval("\x01") != 333)
  2051.                                                    {
  2052.                                                       if(eval("\x01") == 324)
  2053.                                                       {
  2054.                                                          set("\x01",eval("\x01") - 324);
  2055.                                                          break loop0;
  2056.                                                       }
  2057.                                                       break loop0;
  2058.                                                    }
  2059.                                                    set("\x01",eval("\x01") + 196);
  2060.                                                    ┬º┬ºpush(true);
  2061.                                                 }
  2062.                                                 continue;
  2063.                                              }
  2064.                                              set("\x01",eval("\x01") - 299);
  2065.                                              ┬º┬ºgoto(addr2500);
  2066.                                           }
  2067.                                        }
  2068.                                        ┬º┬ºpush(new ┬º┬ºpop()[┬º┬ºpop()]());
  2069.                                     }
  2070.                                     set("\x01",eval("\x01") - 98);
  2071.                                     if(┬º┬ºpop())
  2072.                                     {
  2073.                                        set("\x01",eval("\x01") - 299);
  2074.                                     }
  2075.                                  }
  2076.                                  set("\x01",eval("\x01") + 224);
  2077.                                  continue;
  2078.                               }
  2079.                               set("\x01",eval("\x01") + 249);
  2080.                               continue;
  2081.                            }
  2082.                            set("\x01",eval("\x01") + 124);
  2083.                            ┬º┬ºpush(true);
  2084.                            continue;
  2085.                         }
  2086.                         set("\x01",eval("\x01") - 134);
  2087.                         ┬º┬ºpush(true);
  2088.                      }
  2089.                      set("\x01",eval("\x01") + 354);
  2090.                   }
  2091.                   set("\x01",eval("\x01") + 241);
  2092.                   ┬º┬ºgoto(addr1228);
  2093.                }
  2094.                else
  2095.                {
  2096.                   if(eval("\x01") == 36)
  2097.                   {
  2098.                      set("\x01",eval("\x01") + 762);
  2099.                      if(┬º┬ºpop())
  2100.                      {
  2101.                         set("\x01",eval("\x01") - 356);
  2102.                      }
  2103.                      continue;
  2104.                   }
  2105.                   if(eval("\x01") == 442)
  2106.                   {
  2107.                      set("\x01",eval("\x01") + 388);
  2108.                      continue;
  2109.                   }
  2110.                   if(eval("\x01") == 467)
  2111.                   {
  2112.                      set("\x01",eval("\x01") - 364);
  2113.                      continue;
  2114.                   }
  2115.                   if(eval("\x01") == 122)
  2116.                   {
  2117.                      set("\x01",eval("\x01") + 416);
  2118.                      continue;
  2119.                   }
  2120.                   if(eval("\x01") == 830)
  2121.                   {
  2122.                      break loop2;
  2123.                   }
  2124.                   if(eval("\x01") == 369)
  2125.                   {
  2126.                      set("\x01",eval("\x01") - 266);
  2127.                      if(eval("\t") == 37)
  2128.                      {
  2129.                         break loop0;
  2130.                      }
  2131.                      continue;
  2132.                   }
  2133.                   if(eval("\x01") == 40)
  2134.                   {
  2135.                      set("\x01",eval("\x01") + 414);
  2136.                      ┬º┬ºpush(true);
  2137.                      continue;
  2138.                   }
  2139.                   if(eval("\x01") == 103)
  2140.                   {
  2141.                      set("\x01",eval("\x01") + 118);
  2142.                      ┬º┬ºpush(true);
  2143.                      continue;
  2144.                   }
  2145.                   if(eval("\x01") == 221)
  2146.                   {
  2147.                      set("\x01",eval("\x01") + 671);
  2148.                      if(┬º┬ºpop())
  2149.                      {
  2150.                         set("\x01",eval("\x01") - 770);
  2151.                      }
  2152.                      continue;
  2153.                   }
  2154.                   if(eval("\x01") == 892)
  2155.                   {
  2156.                      set("\x01",eval("\x01") - 770);
  2157.                      break loop0;
  2158.                   }
  2159.                   if(eval("\x01") == 278)
  2160.                   {
  2161.                      set("\x01",eval("\x01") + 54);
  2162.                      if(┬º┬ºpop())
  2163.                      {
  2164.                         set("\x01",eval("\x01") - 310);
  2165.                      }
  2166.                      continue;
  2167.                   }
  2168.                   if(eval("\x01") == 538)
  2169.                   {
  2170.                      set("\x01",eval("\x01") - 260);
  2171.                      ┬º┬ºpush(true);
  2172.                      continue;
  2173.                   }
  2174.                   if(eval("\x01") == 332)
  2175.                   {
  2176.                      set("\x01",eval("\x01") + 37);
  2177.                      set("\t",37);
  2178.                      continue;
  2179.                   }
  2180.                   if(eval("\x01") == 22)
  2181.                   {
  2182.                      set("\x01",eval("\x01") + 18);
  2183.                      continue;
  2184.                   }
  2185.                   if(eval("\x01") == 635)
  2186.                   {
  2187.                      set("\x01",eval("\x01") - 245);
  2188.                      continue;
  2189.                   }
  2190.                   if(eval("\x01") == 213)
  2191.                   {
  2192.                      set("\x01",eval("\x01") + 722);
  2193.                      continue;
  2194.                   }
  2195.                   if(eval("\x01") == 71)
  2196.                   {
  2197.                      set("\x01",eval("\x01") - 31);
  2198.                      continue;
  2199.                   }
  2200.                   if(eval("\x01") == 521)
  2201.                   {
  2202.                      set("\x01",eval("\x01") - 16);
  2203.                      if(┬º┬ºpop())
  2204.                      {
  2205.                         set("\x01",eval("\x01") + 94);
  2206.                      }
  2207.                      continue;
  2208.                   }
  2209.                   if(eval("\x01") == 454)
  2210.                   {
  2211.                      set("\x01",eval("\x01") - 29);
  2212.                      if(┬º┬ºpop())
  2213.                      {
  2214.                         set("\x01",eval("\x01") - 212);
  2215.                      }
  2216.                      continue;
  2217.                   }
  2218.                   if(eval("\x01") != 425)
  2219.                   {
  2220.                      if(eval("\x01") != 223)
  2221.                      {
  2222.                         if(eval("\x01") == 935)
  2223.                         {
  2224.                            set("\x01",eval("\x01") - 414);
  2225.                            ┬º┬ºpush(true);
  2226.                            continue;
  2227.                         }
  2228.                         if(eval("\x01") == 886)
  2229.                         {
  2230.                            set("\x01",eval("\x01") - 56);
  2231.                            continue;
  2232.                         }
  2233.                         if(eval("\x01") != 599)
  2234.                         {
  2235.                            if(eval("\x01") != 390)
  2236.                            {
  2237.                               if(eval("\x01") == 798)
  2238.                               {
  2239.                                  set("\x01",eval("\x01") - 356);
  2240.                                  break loop0;
  2241.                               }
  2242.                               if(eval("\x01") == 477)
  2243.                               {
  2244.                                  set("\x01",eval("\x01") - 477);
  2245.                                  break loop0;
  2246.                               }
  2247.                            }
  2248.                            set("\x01",eval("\x01") - 354);
  2249.                            ┬º┬ºpush(true);
  2250.                         }
  2251.                         set("\x01",eval("\x01") - 209);
  2252.                      }
  2253.                      set("\x01",eval("\x01") + 712);
  2254.                      continue;
  2255.                      continue;
  2256.                      continue;
  2257.                      break loop0;
  2258.                   }
  2259.                   set("\x01",eval("\x01") - 212);
  2260.                   with(┬º┬ºpop())
  2261.                   {
  2262.                   }
  2263.                }
  2264.             }
  2265.          }
  2266.          set("\x01",eval("\x01") - 118);
  2267.          if(!┬º┬ºpop())
  2268.          {
  2269.             continue;
  2270.          }
  2271.          continue loop1;
  2272.       }
  2273.       set("\x01",eval("\x01") - 353);
  2274.       stop();
  2275.       break loop0;
  2276.    }
  2277.    ┬º┬ºgoto(addr771);
  2278. }
  2279.